package com.company.genealogy.common.util;

import com.company.genealogy.common.constant.JwtConstants;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.Optional;

/**
 * 安全上下文工具类
 * 
 * 提供从JWT token中获取用户权限信息的功能，包括：
 * - 获取当前用户ID、用户名、用户类型
 * - 获取用户所属的家族ID、分支ID、成员ID
 * - 提供权限检查方法（管理员、族长、分支管理员等）
 * - 支持从SecurityContext中获取认证信息
 * 
 * 权限级别：
 * - ADMIN：系统管理员，拥有所有权限
 * - CLAN_LEADER：族长，拥有家族管理权限
 * - BRANCH_ADMIN：分支管理员，拥有分支管理权限
 * - MINIAPP：小程序用户，拥有基本查看权限
 * - USER：普通用户，拥有有限权限
 * 
 * @author chenzhixiang
 * @version 1.0
 * @since 2024-01-01
 */
@Component
public class SecurityContextUtil {

    @Autowired
    private JwtUtil jwtUtil;

    /**
     * 获取当前用户ID
     * 
     * @return 用户ID，如果未登录则返回null
     */
    public Optional<Long> getCurrentUserId() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated()) {
            return Optional.empty();
        }
        
        Object principal = authentication.getPrincipal();
        if (principal instanceof org.springframework.security.core.userdetails.UserDetails) {
            String username = ((org.springframework.security.core.userdetails.UserDetails) principal).getUsername();
            try {
                return Optional.of(Long.parseLong(username));
            } catch (NumberFormatException e) {
                return Optional.empty();
            }
        }
        
        return Optional.empty();
    }

    /**
     * 获取当前用户名
     * 
     * @return 用户名，如果未登录则返回null
     */
    public Optional<String> getCurrentUsername() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated()) {
            return Optional.empty();
        }
        
        Object principal = authentication.getPrincipal();
        if (principal instanceof org.springframework.security.core.userdetails.UserDetails) {
            return Optional.of(((org.springframework.security.core.userdetails.UserDetails) principal).getUsername());
        }
        
        return Optional.empty();
    }

    /**
     * 获取当前用户类型
     * 
     * @return 用户类型，如果未登录则返回null
     */
    public Optional<String> getCurrentUserType() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated()) {
            return Optional.empty();
        }
        
        // 从权限列表中查找用户类型
        return authentication.getAuthorities().stream()
                .map(Object::toString)
                .filter(authority -> authority.startsWith("ROLE_"))
                .map(authority -> authority.substring(5)) // 移除 "ROLE_" 前缀
                .findFirst();
    }

    /**
     * 获取当前用户所属家族ID
     * 
     * @return 家族ID，如果未登录或不属于任何家族则返回null
     */
    public Optional<Long> getCurrentUserClanId() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated()) {
            return Optional.empty();
        }
        
        // 从权限列表中查找家族权限
        return authentication.getAuthorities().stream()
                .map(Object::toString)
                .filter(authority -> authority.startsWith("CLAN_"))
                .map(authority -> authority.substring(5)) // 移除 "CLAN_" 前缀
                .findFirst()
                .map(Long::parseLong);
    }

    /**
     * 获取当前用户所属分支ID
     * 
     * @return 分支ID，如果未登录或不属于任何分支则返回null
     */
    public Optional<Long> getCurrentUserBranchId() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated()) {
            return Optional.empty();
        }
        
        // 从权限列表中查找分支权限
        return authentication.getAuthorities().stream()
                .map(Object::toString)
                .filter(authority -> authority.startsWith("BRANCH_"))
                .map(authority -> authority.substring(8)) // 移除 "BRANCH_" 前缀
                .findFirst()
                .map(Long::parseLong);
    }

    /**
     * 获取当前用户成员ID
     * 
     * @return 成员ID，如果未登录或不是成员则返回null
     */
    public Optional<Long> getCurrentUserMemberId() {
        // 这里需要从数据库或缓存中获取，暂时返回null
        // 可以通过用户ID查询用户表获取memberId
        return Optional.empty();
    }

    /**
     * 检查当前用户是否为系统管理员
     * 
     * @return true-是管理员，false-不是管理员
     */
    public boolean isAdmin() {
        return getCurrentUserType()
                .map(userType -> "ADMIN".equalsIgnoreCase(userType))
                .orElse(false);
    }

    /**
     * 检查当前用户是否为族长
     * 
     * @return true-是族长，false-不是族长
     */
    public boolean isClanLeader() {
        return getCurrentUserType()
                .map(userType -> "CLAN_LEADER".equalsIgnoreCase(userType))
                .orElse(false);
    }

    /**
     * 检查当前用户是否为分支管理员
     * 
     * @return true-是分支管理员，false-不是分支管理员
     */
    public boolean isBranchAdmin() {
        return getCurrentUserType()
                .map(userType -> "BRANCH_ADMIN".equalsIgnoreCase(userType))
                .orElse(false);
    }

    /**
     * 检查当前用户是否为小程序用户
     * 
     * @return true-是小程序用户，false-不是小程序用户
     */
    public boolean isMiniAppUser() {
        return getCurrentUserType()
                .map(userType -> "MINIAPP".equalsIgnoreCase(userType))
                .orElse(false);
    }

    /**
     * 检查当前用户是否为普通用户
     * 
     * @return true-是普通用户，false-不是普通用户
     */
    public boolean isUser() {
        return getCurrentUserType()
                .map(userType -> "USER".equalsIgnoreCase(userType))
                .orElse(false);
    }

    /**
     * 检查当前用户是否有指定权限
     * 
     * @param authority 权限名称
     * @return true-有权限，false-无权限
     */
    public boolean hasAuthority(String authority) {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated()) {
            return false;
        }
        
        return authentication.getAuthorities().stream()
                .anyMatch(auth -> auth.getAuthority().equals(authority));
    }

    /**
     * 检查当前用户是否有指定角色
     * 
     * @param role 角色名称（不包含ROLE_前缀）
     * @return true-有角色，false-无角色
     */
    public boolean hasRole(String role) {
        return hasAuthority("ROLE_" + role.toUpperCase());
    }

    /**
     * 检查当前用户是否属于指定家族
     * 
     * @param clanId 家族ID
     * @return true-属于该家族，false-不属于该家族
     */
    public boolean belongsToClan(Long clanId) {
        if (clanId == null) {
            return false;
        }
        
        return getCurrentUserClanId()
                .map(userClanId -> userClanId.equals(clanId))
                .orElse(false);
    }

    /**
     * 检查当前用户是否属于指定分支
     * 
     * @param branchId 分支ID
     * @return true-属于该分支，false-不属于该分支
     */
    public boolean belongsToBranch(Long branchId) {
        if (branchId == null) {
            return false;
        }
        
        return getCurrentUserBranchId()
                .map(userBranchId -> userBranchId.equals(branchId))
                .orElse(false);
    }

    /**
     * 从请求头中获取token并解析用户信息
     * 
     * @param authorizationHeader 授权头
     * @return 用户ID，如果token无效则返回null
     */
    public Optional<Long> getUserIdFromHeader(String authorizationHeader) {
        if (!StringUtils.hasText(authorizationHeader) || !authorizationHeader.startsWith(JwtConstants.BEARER_PREFIX)) {
            return Optional.empty();
        }
        
        String token = authorizationHeader.substring(JwtConstants.BEARER_PREFIX.length());
        if (!jwtUtil.validateToken(token)) {
            return Optional.empty();
        }
        
        return Optional.ofNullable(jwtUtil.getUserIdFromToken(token));
    }

    /**
     * 从请求头中获取token并解析家族ID
     * 
     * @param authorizationHeader 授权头
     * @return 家族ID，如果token无效则返回null
     */
    public Optional<Long> getClanIdFromHeader(String authorizationHeader) {
        if (!StringUtils.hasText(authorizationHeader) || !authorizationHeader.startsWith(JwtConstants.BEARER_PREFIX)) {
            return Optional.empty();
        }
        
        String token = authorizationHeader.substring(JwtConstants.BEARER_PREFIX.length());
        if (!jwtUtil.validateToken(token)) {
            return Optional.empty();
        }
        
        return Optional.ofNullable(jwtUtil.getClanIdFromToken(token));
    }

    /**
     * 从请求头中获取token并解析分支ID
     * 
     * @param authorizationHeader 授权头
     * @return 分支ID，如果token无效则返回null
     */
    public Optional<Long> getBranchIdFromHeader(String authorizationHeader) {
        if (!StringUtils.hasText(authorizationHeader) || !authorizationHeader.startsWith(JwtConstants.BEARER_PREFIX)) {
            return Optional.empty();
        }
        
        String token = authorizationHeader.substring(JwtConstants.BEARER_PREFIX.length());
        if (!jwtUtil.validateToken(token)) {
            return Optional.empty();
        }
        
        return Optional.ofNullable(jwtUtil.getBranchIdFromToken(token));
    }

    /**
     * 从请求头中获取token并解析用户类型
     * 
     * @param authorizationHeader 授权头
     * @return 用户类型，如果token无效则返回null
     */
    public Optional<String> getUserTypeFromHeader(String authorizationHeader) {
        if (!StringUtils.hasText(authorizationHeader) || !authorizationHeader.startsWith(JwtConstants.BEARER_PREFIX)) {
            return Optional.empty();
        }
        
        String token = authorizationHeader.substring(JwtConstants.BEARER_PREFIX.length());
        if (!jwtUtil.validateToken(token)) {
            return Optional.empty();
        }
        
        return Optional.ofNullable(jwtUtil.getUserTypeFromToken(token));
    }
} 